class MyArray <T> {

    //public T[] ts = new T[2];
    //T ts = new T();

    //public T[] ts = (T[])new Object[2];//大多数场景下确实不会报错

    public Object[] objects = new Object[10];

    public void setValue(int pos,T val) {
        objects[pos] = val;
    }


    public T getValue(int pos) {
        return (T)objects[pos];
    }

}
class Person implements Comparable<Person>{

    @Override
    public int compareTo(Person o) {
        return 0;
    }
}
class Student extends Person {

}

//T 一定是 Number或者Number的子类
class TestGeneric<T extends Number> {

}
class TestGeneric2<T extends Person> {

}

//写一个泛型类  求一个数组中的最大值  T 一定是引用数据类型  最终被擦除为了Object 类型
// T类型 一定要是可以比较的  问题：怎么能够约束 这个T 一定是可以比较大小的？ T extends Comparable<T>
// T 一定是实现了 Comparable接口的
class Alg<T extends Comparable<T>> {

    public T findMaxValue(T[] array) {
        T max = array[0];
        for (int i = 1; i < array.length; i++) {
            if(max.compareTo(array[i]) < 0) {
                max = array[i];
            }
        }
        return max;
    }
}

//写一个泛型方法
class Alg2 {
    public<T extends Comparable<T>> T findMaxValue(T[] array) {
        T max = array[0];
        for (int i = 1; i < array.length; i++) {
            if(max.compareTo(array[i]) < 0) {
                max = array[i];
            }
        }
        return max;
    }
}

class Alg3 {
    public static <T extends Comparable<T>> T findMaxValue(T[] array) {
        T max = array[0];
        for (int i = 1; i < array.length; i++) {
            if(max.compareTo(array[i]) < 0) {
                max = array[i];
            }
        }
        return max;
    }
}
public class Test2 {
    public static void main(String[] args) {
        Integer[] integers11 = {1,21,3,4,5,6,7};
        Integer ret11 = Alg3.<Integer>findMaxValue(integers11);
        System.out.println(ret11);

        System.out.println("===============");
        Alg2 alg2 = new Alg2();
        Integer[] integers1 = {1,2,3,4,5,6,7};
        //类型推导：根据实参传值  来推导 此时的类型
        Integer ret1 = alg2.<Integer>findMaxValue(integers1);
        System.out.println(ret1);

        System.out.println("===============");
        Alg<Integer> alg = new Alg<>();
        Integer[] integers = {1,2,3,4,5,6,7};
        Integer ret = alg.findMaxValue(integers);
        System.out.println(ret);

        Alg<Person> alg211 = new Alg<>();
    }
    public static void main2(String[] args) {
        TestGeneric<Number> testGeneric1 = new TestGeneric<>();
        TestGeneric<Integer> testGeneric2 = new TestGeneric<>();
        TestGeneric<Double> testGeneric3 = new TestGeneric<>();

        TestGeneric2<Student> testGeneric4 = new TestGeneric2<>();
        TestGeneric2<Person> testGeneric5 = new TestGeneric2<>();
        //TestGeneric2<Integer> testGeneric6 = new TestGeneric2<>();
    }
    public static void main1(String[] args) {
        //编译的时候 帮我们进行类型的检查 ，取数据不需要进行类型转换
        MyArray<Integer> myArray = new MyArray<>();
        MyArray<String> myArray2 = new MyArray<>();
        MyArray<Person> myArray21 = new MyArray<>();
        //MyArray<int> myArray3 = new MyArray<>();
    }
}
